public class ReadMe {
    /**
     * 2023-4-17 Java基础语法
     * 1.创建项目的时候，选择空项目，不要取引入框架等
     * 2.src一般作为根目录，就是写Java代码的地方
     * 3.一个字节byte有8个bit位
     * 4.二进制和十进制相互转换（使用）
     * 5.计算机硬件就是看得见，摸得着的
     * 6.软件看得见，摸不着的
     * 7.C/S 客户端：服务的端     B/S 浏览器：服务端
     * 8.cmd 了解常用的命令
     * 9.path  环境变量：先在当前目录下找程序，如果找不到，则去环境变量里面找，如果没有，就没有
     * 10.java语言的特点？
     * 11.建议下载一个notepad++，主要用于记事本的编写
     * 12.创建模块
     * 13.创建.java文件
     * 14.编译.java源文件后，会产生.class字节码文件
     * 15.创建类的时候，一般不要直接在src下面创建类，而是需要创建包
     * 16.包创建：com.cn.wanxi.service.JavaClass
     *          com  国际
     *          .cn  国内
     *          .wanxi 公司
     *          .service  模块
     *          .JavaClass  具体类
     *    注意：包名全部小写
     *    每一个包起始是一个文件夹
     *    每一个文件夹下面可能会包含无数个类
     *    一般情况下，包的层次最多4个
     * 17.class 类
     * 18.注释：解释代码的意思
     *      单行注释：  // 解释单行代码，一般放在代码的上面
     *      多行注释：一次性对一段代码进行解释
     *      文档注释：用于类，属性，方法
     *      多写注释；
     *      todo  将要做某事，分配任务
     * 19.关键字：
     * 20.字面量
     *      字符单引号和字符串双引号
     *      字符是指由单个字母数字和中文和特殊字符
     * 21.快捷键
     *      ctrl+d
     *      ctrl+alt+l
     *      ctrl+f 查询
     *      ctrl+r 替换
     *      ctrl+shift+u  大小写相互转换
     * 22.debug 一步一步执行
     * 23.创建类的时候：类名应该用大驼峰命名规则
     *      Java命名规则  username
     *      包名：全部小写，如果功能不同，由多个单词，则用.分开，用.分开会重新创建文件夹
     *      类名：大驼峰  首字母大写 UserName
     *      属性，方法名，字段名：小驼峰  userName
     *      常量：全大写,中间用下划线分开   USER_NAME
     * 24.debug 快捷键 F9  跳转到下一个断点，如果没有断点，则结束程序
     * 25.全局变量和局部变量
     *  全局变量：类下面的变量
     *  局部变量：方法里面的变量
     * 26.如果是全局变量，使用时，有一个默认值，不需要赋初始值
     * 27.如果是局部变量，使用之前，一定要赋初始值
     * 28.变量的作用范围：指当前变量所在的大括号之内
     * 29.标识符：就是起名字的符号。就是一个自己定义的名字
     * 30.以后命名：建议用全英文，不要写关键字即可
     * 31.变量主要是数据，那么数据装在那个地方？用什么容器来存放数据？
     * 32.对于不同的数据，应该用不同的容量的容器来存储
     * 33.数据类型的考点： 4个数据类型  8个基本数据类型
     *      1.默认值  byte   0
     *      2.存储字节数    1
     *      3.取值范围   -128~127
     *      3.定义  byte a=1;
     * 34.整数的默认数据类型位int
     * 35.小数的默认数据类型位double
     * 36.输出： System.out.println(a);
     * 37.输入：需要一个输入的入口？jdk自带的？找到某个类去调用入口？
     * 38.以后如果想要调用别人的类，一般情况下会创建一个对象
     *      Scanner scanner = new Scanner(System.in);
     *      通过new关键字创建一个对象
     *      创建对象后，需要对它进行调用（让它做事情，调用它的方法）
     *      调用方法后需要知道它有没有做事情，需要有一个返回值
     *      将得到的数据装入要给容器即可
     * 39.如果想要引入别人的类，需要先导入别人的类所在的包
     *      import com.cn.wanxi.service.HelloWorld
     */
    /**
     * 2023-4-19 分支和循环
     * 1.要学会简单的优化：尽量让计算机去执行少量的代码
     * 2.能用&&就不用&；
     * 3.以后如果有很多不同的固定的值，首先应该考虑写在一起
     * 4.以后代码里面不允许出现魔法值：固定的值（常量）
     * 5.如果有魔法值，则需要将魔法值单独提取出来（用枚举）
     * 6.switch可以理解为else if
     * 7.以后尽量不要在Java代码里面用switch，建议直接不用
     * 8.可扩展性：如果用switch ，缺少了可扩展性
     * 9.循环格式：for(初始化;条件判断;条件控制){执行体}
     * 10.do while 至少执行一次
     * 11.break；跳出当前循环
     * 12.continue；跳过当前循环，执行下一次循环
     * 13.return；跳出当前方法，后面的都不执行
     * 14.随机数：
     */
    /**
     * 2023-4-20 数组和二维数组
     * 1.Java的数据类型：基本数据类型，引用数据类型
     * 2.基本数据类型 ：八个小类
     * 3.引用数据类型 都有一个基类：Object
     *      平时遇到的引用类型有哪些？
     *          类 接口  枚举  注解  数组
     * 4.数组：同种数据类型，容器
     * 5.如果直接打印引用数据类型，则输出的是hashcode地址
     * 6.每一个基本数据类型都有一个对应的包装类
     * 7.数组通过索引得到里面的值，数组有长度：length属性
     * 8.所有引用数据类型的默认值为null
     * 9.电脑打印到控制台的一般为字符串：而字符串是有字符组成
     * 10.一个英文和数字是有一个字节组成，一个中文如果是UTF-8是由三个字节组成
     * 11.一个中文由多少个字节组成？根据编码格式来确定？
     *      gbk   2
     *      utf-8  3
     *      十六进制  4
     *      gb2312   1
     * 12.动态定义和静态定义
     *      int[] arr={1,2,4};
     *      int[] arr=new int[3];
     * 13.java 运行时，一般会在内存里面开辟三个空间
     * 14.异常：ArrayIndexOutOfBoundsException数组下标越界
     * 15.异常：NullPointerException 空指针异常
     * ----------------------------------
     * 16.数组：
     *      1）数组的定义：静态定义和动态定义
     *      2）数组的取值赋值 int n=  arr[i];   arr[i]=11;
     *      3）数组的遍历   for     arr.length;
     *      4）异常  下标越界  空指针
     * -----------------------------
     * 17.二维数组：数组里面的内容还是一个数组，里面的数组的长度可以不固定
     * 18.二维数组：了解：
     *  能够进行简单的遍历即可
     */
    /**
     * 2023-4-21 方法
     * 1.方法的目的就是为了提高代码的复用性
     * 2.参数是不固定的
     * 3.建议：以后每一个方法，属性，类都需要写注释
     * 4.注释：单行注释，多行注释，文本注释
     * 5.形参   不固定的值:方法里面的参数
     * 6.实参   固定的值：调用方法传递的值
     * 7.建议：以后方法都应该由参数和返回值
     * 8.定义方法的简单格式：private static 返回值数据类型  方法名(参数数据类型 参数名){
     *     执行体
     *     return 返回值;
     * }
     * ---------------------------------------------------
     * 方法定义：
     * 权限修饰符   特征修饰符  返回值数据类型  方法名(参数数据类型 参数名) throws 异常{
     *     执行体
     *     return 返回值；
     * }
     *     public static final int name(String name) throws Exception {
     *         System.out.println(11);
     *         return 1;
     *     }
     * 9.重载：方法名相同，参数类型和个数不同，和返回值类型无关，和权限修饰符无关
     * 10.方法的定义：根据功能不同，定义不同的方法，最好方法里面不能由固定的值
     * 11.方法的命名：见名知意：小驼峰命名
     */
    /**
     * 2023-4-23 案例讲解
     * 1.Java有没有引用传递？Java值传递和引用传递？
     *      Java值传递：基本类型，复制的是值
     *      引用类型，复制的是堆内存的地址
     *      Java只有值传递没有引用传递:引用类型传递的是内存的地址值
     * 2.方法：按照功能模块创建方法，一个方法里面只做一件事情
     * 3.如果很多类里面的方法在其他类里面都是一样的，则可以将方法提到一个公共的类里面
     *      暂时可以这样做
     *      1)将提取到Tool里面的公共方法的private修改为public
     *      2）在其他类直接通过类名.方法名调用即可
     */
    /**
     * 2023-4-24 面向对象
     * 1.方法是按照功能模块取拆分
     * 2.如果这个功能模块非常大：而且里面包含很多不一样的功能
     * 3.考虑能不能将这些功能按照对象的方式进行分开？
     * 4.如果里面的每个功能都不相互联系，影响不大，那么都要分开
     * 5.引用类型：数组，类，接口，抽象，枚举，注解
     * 6.引用类型默认值：默认null
     * 7.类是对对象的抽象表示
     * 8.对象是对类的具体表现
     * ---------------------------
     * 9.类会把对象公共的行为或者特征抽象进去
     *   Java类可以将生活中的对象抽象成Java代码
     *   将生活中的对象的特征理解为Java代码类的属性
     *   将生活中的行为理解为Java代码类的方法
     * 10.以后写项目的时候，首先做的第一件事情：得到项目里面的对象：
     *          理清楚项目里面有哪些对象？
     *          还需要理清对象里面有哪些属性?
     * 11.Java转义字符  \
     * 12.成员变量：类下面的变量
     * 13.局部变量：方法里面的变量
     * 14.如果一个方法只剩下{}，叫做代码块  static{}静态代码块
     * 15.如果方法名和里面一样，其他都省略，还是有{}，则叫做构造方法
     * ------------------------------------------------
     * 16.面向对象基础：
     *      1）属性
     *      2）方法
     *      3）创建对象
     *      4）对象属性和方法的调用
     *      5）内存图
     * 17.java 里面如果名字一样，则有一个就近原则
     * 18.this代表的是，谁调用就是谁
     * 19.构造方法 是有返回值，只不过是对象本身,得到对象的目的就是调用对象的属性和方法
     * 20.构造方法可以重载
     * 21.类里面默认提供了一个无参数的构造方法
     * 22.如果提供了一个有参数的构造方法，则无参数的构造方法失效。
     * 23.一般情况下，写了有参数的构造方法，则需要写无参数的构造方法
     * --------------------------------
     * 24.面向对象的方法：
     *      1）普通方法
     *      2）构造方法：有参数和无参数的区别？
     * 25.面向对象三大特征？面向对象的特点？
     * 26.对于某些属性或者方法，可以进行隐藏，不需要提供给别人调用，则用权限修饰符
     * 27.private  只能当前类使用
     *      public  任何类都可以访问(当前项目：当前模块)
     *      protected  受保护的：以后一般用于子类和父类
     *      默认不写    只能当前包可以访问
     * 28.标准的Javabean 类
     *      1：写出当前类的属性
     *      2：属性的所有权限修饰符为private
     *      3：所有的属性设置set和get方法
     *      4：设置有参数和无参数的构造方法
     *      5:所有的属性数据类型全部用引用类型
     * -------------------------------------
     * 29:今日任务：将第一阶段的项目里面的对象全部找出，设置成标准的Javabean
     * 30：你认为哪些文字或者图片需要修改，都应该提取成对象
     *      公司
     *      导航
     *      新闻
     *      新闻类型
     *      产品
     *      产品类型
     *      留言
     */
    /**
     * 2023-4-25 字符串
     * 1.面向对象：完整的Javabean
     * 2.字符串的构造方法
     * 3.字符串比较 ==    equals
     * 4.字符串遍历：将字符串转换为字符数组char[] chars = str.toCharArray();
     * 5.如果想要遍历字符串，除了toCharArray，还可以结合字符串长度和索引
     *      str.length()    charAt(index);
     *      数组的长度是length属性还是length方法？
     *      字符串的长度是length属性还是length方法？
     * 6.String 和StringBuilder和StringBuffer的区别？
     *      一般局部变量，至是用于少量的变量赋值用string
     * 7.substring  [start,end)
     * 8.substring(start)
     * 9.str=replace(oldString,newString);
     * 10.split 分割字符串，里面的参数是分隔符，不能包含特殊字符，如果需要，则用正则表达式
     *
     *
     */
    /**
     * 2023-4-26 集合基础
     * 1.字符串常用的方法？
     *      1）toString()
     *      2)构造方法
     *      3）equals  返回的是布尔值
     *      4）substring
     *      5）split
     *      6）replace
     *      7）charAt
     *      8)toCharArray
     *      9)toUpperCase
     *      10)toLowerCase
     *      11)trim 去掉字符串两端的空格
     *      12)length
     *      13)getBytes 得到字节数组：编码格式getBytes("utf-8")
     *      14)startWith("aa") 以什么字符开始
     *      15)endWith("aa")
     *      16)contain("aa") 是否包含当前字符
     *      17)indexOf 根据当前字符拿到字符所在的索引位置
     *      18)compareTo  比较字符串的值是否相等  返回的整型，
     *              如果为0，表示相等
     *              正数，表示后面的大于前面的
     *              负数，表示后面的小于前面的
     *              一般用于排序
     *              a.compareTo(b);
     * 2.动态扩容数组
     *      1）创建一个数组 a
     *      2）创建一个新数组 b  新数组比原数组的长度大1
     *      3）将原数组的数据复制到新数组，将新的信息赋值到新数组的最后一个
     *      4）返回一个新数组，继续2-4的步骤
     * 3.其实，集合就是对数组的封装，就是动态扩容数组
     * 4.ArrayList集合的构造方法
     * 5.集合的添加
     *      add(E)
     *      add(index,E)
     * 6.集合的删除
     *      remove(E) 一定对象的地址，不是new的对象
     *      remove(index);
     * 7.集合的修改
     *      set(index,E)
     * 8.集合的获取
     *      get(index);
     * 9.集合的长度
     *      size();
     * 10.数组的长度 length;
     * 11.对集合的增加，修改，删除，查询（遍历），条件查询
     * 12.练习题：学生管理系统
     *      1.要让用户手动退出：System.exit(0);
     *      2.用户要一直可以输入，则需要死循环
     *      3.每次增加的信息必须在其他地方都可以拿到，则需要将集合放在循环外面
     *      4.对于有些重复代码可以写到公共的类里面进行调用
     *
     *
     */
    /**
     * 2023-4-27 面向对象之继承
     * 1.面向对象基础：
     *      1）怎么创建一个完整的JavaBean
     *      2）属性，方法，构造方法
     *      3）JavaBean一般情况下所有属性全是私有，（封装，隐藏不必要的信息）
     * 2.基本类型 和包装类
     *      基本类型：只用于赋值  int a=1;
     *      包装类：是对基本类型的复杂化：引用类型
     *      byte   Byte
     *      short  Short
     *      int  Integer
     *      long Long
     *      float Float
     *      double Double
     *      char  Character
     *      boolean     Boolean
     * 3.面向对象三大特征：继承，封装，多态：抽象
     * 4.任何一个普通类的父类都可以理解为Object
     * 5.super()  可以理解为调用父类的构造方法
     * 6.super()必须放在第一行
     * 7.this和super不能一起用，而且都只能放在第一行
     * 8.子类的构造方法里面默认有一个父类的无参数的构造方法
     * 9.方法的重载：方法名相同，类型和个数不同：和返回值类型无关
     * 10.方法的重写：子类和父类有一模一样的方法：
     * 11.方法的重写和返回值类型相关：子类的返回值必须小于等于父类的返回值类型
     * 12.方法的重写和修饰符相关：子类的修饰符必须大于等于父类的修饰符
     * 13.java中类包含哪些？Java中接口属不属于类？
     * 14.接口是属于类，接口属于抽象类，抽象类属于类
     * 15.Java普通类不支持多继承,接口支持多继承
     * 16.private 只能在当前类使用
     * 17.默认不写 只能在当前包使用
     * 18.protected  只能用于父类
     * 19.public 只能用于当前项目：任何地方都可以直接调用
     * 20.final面试？
     * 21.static的使用？
     *      如果你想要变量共享数据 ，则用static
     *      直接用类名.属性名
     *      类名.方法名
     * 22.静态方法 不能调用非静态的变量和方法，可以调用静态方法和属性
     * 23.非静态方法 可以调用静态和非静态的方法和属性
     * 24.static应用：一般用于工具类，如果不用static表示每次方法对象都会重新开辟空间
     *          如果用static只会开辟一次，节约空间：数据共享
     * 25.代码块先于构造方法执行
     * 26.静态代码块 加载类的时候执行
     * 27.代码块在创建类之前执行
     * 28.静态代码块 > 代码块 > 构造方法
     * -----------------------------------------------------
     * 总结：
     * 继承：公共的代码：属性和方法：提取到父类 extends
     * final  修饰类，属性，方法
     * static  资源共享  一般用于工具类
     */
    /**
     * 2023-4-28 多态
     * 1.多态好处：提高了程序的可扩展性
     * 2.   向上转型   范围小的转换为范围大的
     *      向下转型
     *      byte b=1;
     *      int i=2;
     *      i=b;//向上  隐式转换
     *      b=i;//向下  溢出   精度丢失，强制转换
     * 3.多态的：
     *      1）有父类和子类的关系
     *      2）有重写
     *      3）父类引用指向子项子类
     * 4.如果多态的时候，都是调用子类重写的方法，则父类的方法没有使用到
     * 5.父类既然没有使用到，或者需求子类必须重写父类的方法，那么父类的方法则可以不用写方法体
     * 6.如果省略父类的代码块，则报错，需要将方法设定为抽象方法
     *      父类的方法没有做任何事情，则可以理解为一个抽象方法
     *      如果方法设定为抽象方法，则当前类必须为抽象类
     *      abstract
     * 7.抽象方法主要的目的，是子类必须重写
     * 8.抽象类里面可以有普通方法
     * 9.抽象类里面必须有抽象方法？抽象方法的类必须是抽象类？
     * 10.抽象类可以实例化，只不过必须重写抽象类里面的所有抽象方法
     * -----------------------------------------------
     * 11.理解多态：父类  aa=new 子类(); 父类和子类的关系可以是继承，实现
     * 12.理解抽象：抽象类和抽象方法，抽象的目的是让子类必须重写当前的方法
     * 13.继承：提起相同的属性和方法
     * 14.抽象其实是对继承的封装
     */



}
